// 请求拦截器
import interceptor from '../../../utils/config/http.interceptor';

// HTTP请求封装
const http = {
    /**
     * 公用网络请求（需自行处理success）
     * @param {object} options 网络通讯参数
     */
    request: (options = {}) => {
        // 请求拦截器
        if(interceptor.request && typeof interceptor.request === 'function') {
            interceptor.request(options);
        }

        options.timeout = interceptor.config.timeout; // 超时时间，单位为毫秒
        options.header = Object.assign(interceptor.config.header, options.header); // 请求头
		options.dataType = options.dataType || interceptor.config.dataType; // 预期服务器返回的数据类型
		options.responseType = options.responseType || interceptor.config.responseType; // 设置服务器返回的数据类型

        return new Promise((resolve, reject) => {
            // 响应完成后
            options.complete = (response) => {
                // 请求返回后，隐藏loading
                wx.hideLoading();
                // 完成停止加载
                wx.hideNavigationBarLoading();
                // 停止下拉刷新
                wx.stopPullDownRefresh();
                // 清除定时器，如果请求回来了，就无需loading
				clearTimeout(interceptor.config.timer);
                interceptor.config.timer = null;

                // 判断用户对拦截返回数据的要求，如果originalData为true，返回所有的数据(response)到拦截器，否则只返回response.data
                if(interceptor.originalData){
                    // 判断是否存在拦截器
					if (interceptor.response && typeof interceptor.response === 'function') {
						let resInterceptors = interceptor.response(response);
						// 如果拦截器不返回false，就将拦截器返回的内容给wx.$g.post的then回调
						if (resInterceptors !== false) {
							resolve(resInterceptors);
						} else {
							// 如果拦截器返回false，意味着拦截器定义者认为返回有问题，直接接入catch回调
							reject(response);
						}
					} else {
						// 如果要求返回原始数据，就算没有拦截器，也返回最原始的数据
						resolve(response);
					}
                } else if (response.statusCode == 200) {
                    // 判断是否存在拦截器
                    if (interceptor.response && typeof interceptor.response === 'function') {
                        let resInterceptors = interceptor.response(response);
                        // 如果拦截器不返回false，就将拦截器返回的内容给this.$g.post的then回调
                        if (resInterceptors !== false) {
                            resolve(resInterceptors);
                        } else {
                            // 如果拦截器返回false，意味着拦截器定义者认为返回有问题，直接接入catch回调
                            reject(response);
                        }
                    } else {
                        // 如果不是返回原始数据(originalData=false)，且没有拦截器的情况下，返回纯数据给then回调
                        resolve(response.data);
                    }
                } else {
                    // 不返回原始数据的情况下，服务器状态码不为200，modal弹框提示
                    wx.showToast({
                        title: '请求失败, 请稍后再试！',
                        icon: 'none',
                        duration: 2000
                    })
                    console.error("请求失败，请求接口：" + options.url + ", 异常原因:", response);
                    reject(response)
                }
            }

			// 是否显示loading
			// 加一个是否已有timer定时器的判断，否则有两个同时请求的时候，后者会清除前者的定时器id
            // 而没有清除前者的定时器，导致前者超时，一直显示loading
            if (interceptor.config.showLoading && !interceptor.config.timer) {
                interceptor.config.timer = setTimeout(() => {
                    wx.showLoading({
                        title: interceptor.config.loadingTitle, // 提示的内容
                        mask: interceptor.config.loadingMask // 是否显示透明蒙层，防止触摸穿透
                    });
					interceptor.config.timer = null;
				}, interceptor.config.loadingTime);
            }
            wx.request(options);
        }).catch(response => {
            // 如果返回reject()，不让其进入this.$u.post().then().catch()后面的catct()
			// 因为很多人都会忘了写后面的catch()，导致报错捕获不到catch
			return new Promise(()=>{});
        });
    },

    /**
     * POST网络请求
     * @param {String} url:请求地址
     * @param {Object} data: 请求参数
     * @param {Object} header: 请求头参数
     */
    post: (url, data = {}, header = {}) => {
        return http.request({
            url,
            method: 'POST',
            header,
            data
        })
    },

    /**
     * GET网络请求
     * @param {String} url:请求地址
     * @param {Object} data: 请求参数
     * @param {Object} header: 请求头参数
     */
    get: (url, data = {}, header = {}) => {
        return http.request({
            url,
            method: 'GET',
            header,
            data
        })
    },

    /**
     * PUT网络请求
     * @param {String} url:请求地址
     * @param {Object} data: 请求参数
     * @param {Object} header: 请求头参数
     */
    put: (url, data = {}, header = {}) => {
        return http.request({
            url,
            method: 'PUT',
            header,
            data
        })
    },


    /**
     * DELETE网络请求
     * @param {String} url:请求地址
     * @param {Object} data: 请求参数
     * @param {Object} header: 请求头参数
     */
    del: (url, data = {}, header = {}) => {
        return http.request({
            url,
            method: 'DELETE',
            header,
            data
        })
    },
}

export default {
    /**GET请求 */
    get: http.get,
    /**POST请求 */
    post: http.post,
    /**PUT请求 */
    put: http.put,
    /**DELETE请求 */
    del: http.del,
};
